// #include <functional>
// #include <iostream>
// using namespace std;
// int main() {
//     []{};
//     return 0;
// }

// [capture-list] (parameters)-> return type {
//     function body
// }
// #include <iostream>
// using namespace std;
// int main() {
//     auto add = [](int x, int y)->int {
//         return x + y;
//     };
//     cout << add(1, 2) << endl;
//     auto func = [] {
//         cout << "hello world!" << endl;
//     };
//     func();
//     int a = 1, b = 2;
//     auto swap = [](int& x, int& y) {
//         int temp = x;
//         x = y;
//         y = temp;
//     };
//     swap(a, b);
//     cout << a << ":" << b << endl;
//     return 0;
// }

// #include <iostream>
// using namespace std;
// int x = 0;
// // 这里是全局，没有什么可以捕捉的变量
// auto func1 = []() {
//     x++;
// };
// int main() {
//     int a = 0, b = 1, c = 2, d = 3;
//     auto func2 = [a, &b] {
//         // 值的捕捉不可以修改，但是引用捕捉的变量是可以修改的
//         // a++; // 报错
//         b++;
//         int ret = a + b;
//         return ret;
//     };
//     cout << func2() << endl; 
//     cout << b << endl;
//     cout << "*********************" << endl;
//     // 隐式值捕捉
//     auto func3 = [=] {
//         int ret = a + b + c;
//         return ret;
//     };
//     cout << func3() << endl;
//     cout << "*********************" << endl;
//     // 隐式引用捕捉
//     cout << a << " " << b << " " << c << " " << d << endl;
//     auto func4 = [&] {
//         a++;
//         c++;
//         d++;
//     };
//     func4();
//     cout << a << " " << b << " " << c << " " << d << endl;
//     cout << "*********************" << endl;
//     // 混合捕捉1
//     cout << a << " " << b << " " << c << " " << d << endl;
//     auto func5 = [&, a, b] {
//         // a++; // 报错
//         // b++; // 报错
//         c++;
//         d++;
//     };
//     cout << a << " " << b << " " << c << " " << d << endl;
//     cout << "*********************" << endl;
//     // 混合捕捉2
//     cout << a << " " << b << " " << c << " " << d << endl;
//     auto func6 = [=, &a, &b] {
//         a++;
//         b++;
//         // c++; // 报错
//         // d++; // 报错
//     };
//     func6();
//     cout << a << " " << b << " " << c << " " << d << endl;
//     cout << "*********************" << endl;
//     // 局部静态变量和全局变量不能捕捉，也不需要捕捉
//     static int y = 2;
//     auto func7 = [] {
//         int ret = x + y;
//         return ret;
//     };
//     cout << func7() << endl;
//     cout << "*********************" << endl;
//     // 传值捕捉是拷贝默认是被const修饰的
//     // 使用mutable可以消去const属性，但是我们的改变并不会影响外面的值
//     cout << a << " " << b << " " << c << " " << d << endl;
//     auto func8 = [=]()mutable {
//         a++;
//         b++;
//         c++;
//         d++;
//         return a + b + c + d;
//     };
//     cout << func8() << endl;
//     cout << a << " " << b << " " << c << " " << d << endl;
//     cout << "*********************" << endl;
//     return 0;
// }


// #include <iostream>
// #include <vector>
// #include <algorithm>
// using namespace std;
// struct Goods {
//     string _name; // 商品名
//     double _price; // 商品价格
//     int _evaluate; // 商品评价
//     // 构造函数
//     Goods(const char* name, double price, int evaluate)
//     :_name(name)
//     ,_price(price)
//     ,_evaluate(evaluate){}
// };

// struct ComparePriceLess {
//     bool operator()(const Goods& g1, const Goods& g2) {
//         return g1._price < g2._price;
//     }
// };

// struct ComparePriceGreater {
//     bool operator()(const Goods& g1, const Goods& g2) {
//         return g1._price > g2._price;
//     }
// };

// int main() {
//     vector<Goods> v = {{"苹果", 1.2, 5}, {"香蕉", 3.3, 3}, {"橘子", 2.3, 4}, {"栗子", 1.1, 5}};
//     // 使用我们的仿函数
//     // 按价格升序
//     sort(v.begin(), v.end(), ComparePriceLess());
//     // 按价格降序
//     sort(v.begin(), v.end(), ComparePriceLess());
//     // 使用我们的lambda表达式
//     // 按价格升序
//     sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//         return g1._price < g2._price;
//     });
//     // 按价格降序
//     sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//         return g1._price > g2._price;
//     });
//     // 实现评价从低到高
//     sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//         return g1._evaluate < g2._evaluate;
//     });
//     // 实现评价从高到低
//     sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//         return g1._evaluate > g2._evaluate;
//     });
//     return 0;
// }


// #include <iostream>
// using namespace std;
// class Rate {
//     public:
//         Rate(double rate) : _rate(rate) {}
//         double operator()(double money, int year) {
//             return money * _rate * year;
//         }
//     private:
//         double _rate;
// };

// int main() {
//     double rate = 0.21;
//     // 使用lambda表达式
//     auto r1 = [rate](double money, int year) {
//         return money * rate * year; 
//     };
//     // 使用函数对象
//     Rate r2(rate);
//     r2(10000, 3);

//     r1(10000, 3);
//     return 0;
// }


#include <iostream>
#include <typeinfo>
#include <typeindex>
using namespace std;
class Rate {
    public:
        Rate(double rate) : _rate(rate) {}
        double operator()(double money, int year) {
            return money * _rate * year;
        }
    private:
        double _rate;
};

int main() {
    double rate = 0.12;
    auto r1 = [rate](double money, int year) {
        return money * rate * year; 
    };
    auto r2 = [rate](double money, int year) {
        return money * rate * year; 
    };
    cout << typeid(r1).name() << endl;
    cout << typeid(r2).name() << endl;
    return 0;
}